home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sph_mac.hqx / SRGP port to 5.0 (compressed) / SRGP_SPHIGS Root / MacSRGP / srgp_output.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-13  |  24.6 KB  |  1,079 lines
  1. #include "HEADERS.h"
  2. #include "srgplocal.h"
  3.  
  4.  
  5. #define TURN_OFF_RUBBER_ECHO_IF_ANY \
  6.    SRGP__disableLocatorRubberEcho()
  7.  
  8. #define TURN_ON_RUBBER_ECHO_IF_ANY \
  9.    SRGP__enableLocatorRubberEcho()
  10.   
  11. /* JJR */
  12. typedef void (*voidfuncptr)();
  13.  
  14. #ifdef THINK_C
  15. static Rect r;
  16.  
  17. #define DONT_DRAW  -1   /* must match srgp_attrib.c */
  18.  
  19.  
  20. #define SET_PORT_FOR_FRAME_GENRE() \
  21. if (srgp__curActiveCanvasSpec.transfermode_frame == DONT_DRAW) return; else { \
  22.    PenMode (srgp__curActiveCanvasSpec.transfermode_frame); \
  23.    PenPat (srgp__curActiveCanvasSpec.pat_frame); }
  24.  
  25. #define SET_PORT_FOR_FILL_GENRE() \
  26. if (srgp__curActiveCanvasSpec.transfermode_fill == DONT_DRAW) return; else { \
  27.    PenMode (srgp__curActiveCanvasSpec.transfermode_fill); \
  28.    PenPat (srgp__curActiveCanvasSpec.pat_fill); }
  29.  
  30. #endif
  31.  
  32. #include "srgp_output.proto.h"
  33. static void GetReadyToPaintMarkers(void);
  34. static void FinishPaintingMarkers(void);
  35. static void plotdash(int, int, int);
  36. static void plotdot(int, int, int);
  37. static void plotdotdash(int, int, int);
  38. static void LS_MOVETO(int, int);
  39. static void LS_LINETO_difficult(int, int, voidfuncptr);
  40. static void LS_LINETO(int, int);
  41.  
  42.  
  43.  
  44. /** Functions creating geometric data 
  45. **/
  46.  
  47. point SRGP_defPoint (int x, int y)
  48. {
  49.    point pt;
  50.  
  51.    pt.x = x;
  52.    pt.y = y;
  53.    return pt;
  54. }
  55.  
  56. rectangle SRGP_defRectangle (int left_x, int bottom_y, int right_x, int top_y)
  57. {
  58.    rectangle rect;
  59.  
  60.    rect.bottom_left.x = left_x;
  61.    rect.bottom_left.y = bottom_y;
  62.    rect.top_right.x = right_x;
  63.    rect.top_right.y = top_y;
  64.    return rect;
  65. }
  66.  
  67.  
  68.  
  69.  
  70. /** AUDIO
  71. **/
  72.  
  73. void
  74. SRGP_beep(void)
  75. {
  76. #ifdef X11
  77.    XBell (srgpx__display, 0);
  78. #endif
  79. #ifdef THINK_C
  80.    SysBeep(30);
  81. #endif
  82. }
  83.  
  84.  
  85.  
  86.  
  87.  
  88. /** POINTS 
  89. **/
  90.  
  91. void
  92. SRGP_pointCoord (int x, int y)
  93. {
  94.    DEBUG_AIDS{
  95.       SRGP_trace (SRGP_logStream, "SRGP_pointCoord: %d,%d\n", x,y);
  96.       srgp_check_system_state();
  97.       LeaveIfNonFatalErr();
  98.    }
  99.  
  100.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  101. #ifdef X11
  102.    XDrawPoint
  103.       (srgpx__display,
  104.        srgp__curActiveCanvasSpec.drawable.xid,
  105.        srgp__curActiveCanvasSpec.gc_frame,
  106.        x, FIXED(y));
  107. #endif
  108. #ifdef THINK_C
  109.    SET_PORT_FOR_FRAME_GENRE();
  110.    MoveTo(x,FIXED(y));
  111.    Line(0,0);
  112. #endif
  113.    TURN_ON_RUBBER_ECHO_IF_ANY;
  114. }
  115.  
  116. void
  117. SRGP_point (point pt)
  118. {
  119.    DEBUG_AIDS{
  120.       SRGP_trace (SRGP_logStream, "SRGP_point: %d,%d\n", ExplodePt(pt));
  121.    }
  122.  
  123.    PUSH_TRACE;
  124.    SRGP_pointCoord (pt.x, pt.y);
  125.    POP_TRACE;
  126. }
  127.  
  128. void
  129. SRGP_polyPoint (int vertex_count, point *vertices)
  130. {
  131.    register int i;
  132.  
  133.    DEBUG_AIDS{
  134.       SRGP_trace (SRGP_logStream, "SRGP_polyPoint  %d 0x%x\n", 
  135.            vertex_count, vertices);
  136.       srgp_check_system_state();
  137.       srgp_check_polymarker_list_size(vertex_count);
  138.       LeaveIfNonFatalErr();
  139.    }
  140.  
  141.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  142.  
  143. #ifdef X11
  144.    for (i=0; i<vertex_count; i++) {
  145.       Xformat_vertices[i].x = vertices[i].x;
  146.       Xformat_vertices[i].y = FIXED(vertices[i].y);
  147.    } 
  148.    XDrawPoints
  149.       (srgpx__display,
  150.        srgp__curActiveCanvasSpec.drawable.xid,
  151.        srgp__curActiveCanvasSpec.gc_frame,
  152.        Xformat_vertices, vertex_count, CoordModeOrigin);
  153. #endif
  154.  
  155. #ifdef THINK_C
  156.    PUSH_TRACE;
  157.    for (i=0; i<vertex_count; i++)
  158.       SRGP_pointCoord (vertices[i].x, FIXED(vertices[i].y));
  159.    POP_TRACE;
  160. #endif
  161.  
  162.    TURN_ON_RUBBER_ECHO_IF_ANY;
  163. }
  164.  
  165.  
  166. void
  167. SRGP_polyPointCoord (int vertex_count, int *x_coords, int *y_coords)
  168. {
  169.    register int i;
  170.  
  171.    DEBUG_AIDS{
  172.       SRGP_trace (SRGP_logStream, "SRGP_polyPointCoord  %d 0x%x,0x%x\n",
  173.           vertex_count, x_coords, y_coords);
  174.       srgp_check_system_state();
  175.       srgp_check_polymarker_list_size(vertex_count);
  176.       LeaveIfNonFatalErr();
  177.    }
  178.  
  179.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  180.    
  181. #ifdef X11
  182.    for (i=0; i < vertex_count; i++) {
  183.       Xformat_vertices[i].x = x_coords[i];
  184.       Xformat_vertices[i].y = FIXED(y_coords[i]);
  185.    } 
  186.    XDrawPoints
  187.       (srgpx__display,
  188.        srgp__curActiveCanvasSpec.drawable.xid,
  189.        srgp__curActiveCanvasSpec.gc_frame,
  190.        Xformat_vertices, vertex_count, CoordModeOrigin);
  191. #endif
  192.  
  193. #ifdef THINK_C
  194.    PUSH_TRACE;
  195.    for (i=0; i<vertex_count; i++)
  196.       SRGP_pointCoord (x_coords[i], FIXED(y_coords[i]));
  197.    POP_TRACE;
  198. #endif
  199.  
  200.    TURN_ON_RUBBER_ECHO_IF_ANY;
  201. }
  202.  
  203.  
  204.  
  205.  
  206. /** MARKERS
  207. **/
  208.  
  209. extern int srgp__marker_radius;  /* found in marker.c */
  210. static int linewidthtemp, saveLineWidth;
  211.  
  212. static void
  213. GetReadyToPaintMarkers (void)
  214. {
  215.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  216.    PUSH_TRACE;
  217.  
  218.    srgp__marker_radius = srgp__curActiveCanvasSpec.attributes.marker_size >> 1;
  219.  
  220. #ifdef THINK_C
  221.    SET_PORT_FOR_FRAME_GENRE();
  222. #endif
  223.  
  224.    saveLineWidth = srgp__curActiveCanvasSpec.attributes.line_width;
  225.    SRGP_setLineWidth
  226.       (((linewidthtemp=(srgp__marker_radius>>3))==0)?1:linewidthtemp);
  227. }
  228.  
  229.  
  230. static void
  231. FinishPaintingMarkers (void)
  232. {
  233.    SRGP_setLineWidth (saveLineWidth);
  234.  
  235.    POP_TRACE;
  236.    TURN_ON_RUBBER_ECHO_IF_ANY;
  237. }   
  238.  
  239.  
  240.    
  241. void 
  242. SRGP_markerCoord (int x, int y)
  243. {
  244.    DEBUG_AIDS{
  245.       SRGP_trace (SRGP_logStream, "SRGP_markerCoord: %d,%d\n", x,y);
  246.       srgp_check_system_state();
  247.       LeaveIfNonFatalErr();
  248.    }
  249.  
  250.    GetReadyToPaintMarkers();
  251.    switch (srgp__curActiveCanvasSpec.attributes.marker_style) {
  252.     case MARKER_CIRCLE: SRGP__drawCircleMarker (x,y); break;
  253.     case MARKER_SQUARE: SRGP__drawSquareMarker (x,y); break;
  254.     case MARKER_X: SRGP__drawXMarker (x,y); break;
  255.    }
  256.    FinishPaintingMarkers();
  257. }
  258.  
  259.    
  260. void 
  261. SRGP_marker (point pt)
  262. {
  263.    DEBUG_AIDS{
  264.       SRGP_trace (SRGP_logStream, "SRGP_marker: %d,%d\n", pt.x, pt.y);
  265.       srgp_check_system_state();
  266.       LeaveIfNonFatalErr();
  267.    }
  268.  
  269.    GetReadyToPaintMarkers();
  270.    switch (srgp__curActiveCanvasSpec.attributes.marker_style) {
  271.     case MARKER_CIRCLE: SRGP__drawCircleMarker (pt.x,pt.y); break;
  272.     case MARKER_SQUARE: SRGP__drawSquareMarker (pt.x,pt.y); break;
  273.     case MARKER_X: SRGP__drawXMarker (pt.x,pt.y); break;
  274.    }
  275.    FinishPaintingMarkers();
  276. }
  277.  
  278.    
  279. void 
  280. SRGP_polyMarker (int vertex_count, point *vertices)
  281. {
  282.    DEBUG_AIDS{
  283.       SRGP_trace (SRGP_logStream, "SRGP_polyMarker: %d  %lx\n", 
  284.           vertex_count, vertices);
  285.       srgp_check_polymarker_list_size(vertex_count);
  286.       srgp_check_system_state();
  287.       LeaveIfNonFatalErr();
  288.    }
  289.  
  290.    GetReadyToPaintMarkers();
  291.    while (vertex_count--) {
  292.       switch (srgp__curActiveCanvasSpec.attributes.marker_style) {
  293.        case MARKER_CIRCLE: 
  294.      SRGP__drawCircleMarker (vertices->x,vertices->y); break;
  295.        case MARKER_SQUARE: 
  296.      SRGP__drawSquareMarker (vertices->x,vertices->y); break;
  297.        case MARKER_X: 
  298.      SRGP__drawXMarker (vertices->x,vertices->y); break;
  299.       }
  300.       vertices++;
  301.    }
  302.    FinishPaintingMarkers();
  303. }
  304.  
  305.    
  306. void 
  307. SRGP_polyMarkerCoord (int vertex_count, int *xlist, int *ylist)
  308. {
  309.    DEBUG_AIDS{
  310.       SRGP_trace (SRGP_logStream, "SRGP_polyMarkerCoord: %d  %lx %lx\n", 
  311.           vertex_count, xlist, ylist);
  312.       srgp_check_polymarker_list_size(vertex_count);
  313.       srgp_check_system_state();
  314.       LeaveIfNonFatalErr();
  315.    }
  316.  
  317.    GetReadyToPaintMarkers();
  318.    while (vertex_count--) {
  319.       switch (srgp__curActiveCanvasSpec.attributes.marker_style) {
  320.        case MARKER_CIRCLE: SRGP__drawCircleMarker (*xlist, *ylist); break;
  321.        case MARKER_SQUARE: SRGP__drawSquareMarker (*xlist, *ylist); break;
  322.        case MARKER_X: SRGP__drawXMarker (*xlist, *ylist); break;
  323.       }
  324.       xlist++; ylist++;
  325.    }
  326.    FinishPaintingMarkers();
  327. }
  328.  
  329.    
  330.  
  331. /** LINES
  332. X11 handles dashes, etc. itself.
  333. Macintosh:  we must simulate all line styles other than continuous.
  334. **/
  335.  
  336.  
  337. #ifdef THINK_C
  338. /* JJR
  339. typedef void (*voidfuncptr)();
  340. */
  341. static int xpresent, ypresent;
  342. static boolean off;
  343.  
  344.  
  345. static void plotdash (int x, int y, int s)
  346. {
  347.    int j = s % 10;
  348.    off = (j < 5);
  349.    if ( ! off) {
  350.       MoveTo (x, y);
  351.       LineTo (x, y);
  352.    }
  353. }
  354.  
  355.  
  356. static void plotdot (int x, int y, int s)
  357. {
  358.    int j = s % 7;
  359.    off = (j < 5);
  360.    if ( ! off ) {
  361.       MoveTo (x, y);
  362.       LineTo (x, y);
  363.    }
  364. }
  365.  
  366.  
  367.  
  368. static void plotdotdash (int x, int y, int s)
  369. {
  370.    int j = s % 15;
  371.    off = (j < 4) || ((j > 5) && (j < 9));
  372.    if ( ! off) {
  373.       MoveTo (x, y);
  374.       LineTo (x, y);
  375.    }
  376. }
  377.  
  378.  
  379. static void LS_MOVETO (int x, int y)   /*Already Mac coordinates*/
  380. {
  381.    xpresent = x;
  382.    ypresent = y;
  383.    MoveTo (xpresent, ypresent);
  384. }
  385.  
  386.  
  387. static void LS_LINETO_difficult 
  388.    (int xnew, int ynew, 
  389.     voidfuncptr plot_with_line_style)
  390. {
  391.    register long_step, short_step, ax, di, bp, si, temp, x, y;
  392.    
  393.    long_step = 1;
  394.    short_step = 1;
  395.    bp = xnew - xpresent;
  396.    if (bp < 0)
  397.       {
  398.      long_step = -1;
  399.      bp = -bp;
  400.       };
  401.    ax = ynew - ypresent;
  402.    if (ax < 0)
  403.       {
  404.      short_step = -1;
  405.      ax = -ax;
  406.       };
  407.    x = xpresent;
  408.    y = ypresent;
  409.    if (ax <= bp)
  410.       {
  411.      di = bp>>1;
  412.      si = 0;
  413.      do {
  414.         plot_with_line_style (x, y, si);
  415.         x += long_step;
  416.         di += ax;
  417.         if (di >= bp)
  418.            {
  419.           di -= bp;
  420.           y += short_step;
  421.            }
  422.      }
  423.      while ((++si) <= bp);
  424.       }
  425.    else
  426.       {
  427.      temp = ax;
  428.      ax = bp;
  429.      bp = temp;
  430.      temp = short_step;
  431.      short_step = long_step;
  432.      long_step = temp;
  433.      di = (bp>>1);
  434.      si = 0;
  435.      do {
  436.         plot_with_line_style (x, y, si);
  437.         y += long_step;
  438.         di += ax;
  439.         if (di >= bp)
  440.            {
  441.           di -= bp;
  442.           x += short_step;
  443.            }
  444.      }
  445.      while ((++si) <= bp);
  446.       }
  447. }
  448.  
  449.  
  450. static void LS_LINETO (int xnew, int ynew) 
  451. {
  452.    if (srgp__curActiveCanvasSpec.attributes.line_style == CONTINUOUS)
  453.       LineTo (xnew, ynew);
  454.    else {
  455.       if (xnew == xpresent) 
  456.      PenSize (srgp__curActiveCanvasSpec.attributes.line_width, 1);
  457.       else if (ynew == ypresent) 
  458.      PenSize (1, srgp__curActiveCanvasSpec.attributes.line_width);
  459.       else if (abs(ynew - ypresent) < abs(xnew - xpresent))
  460.      PenSize (1, srgp__curActiveCanvasSpec.attributes.line_width);
  461.       else
  462.      PenSize (srgp__curActiveCanvasSpec.attributes.line_width, 1);
  463.       
  464.       switch (srgp__curActiveCanvasSpec.attributes.line_style) {
  465.        case DASHED: 
  466.      LS_LINETO_difficult (xnew, ynew, plotdash); break;
  467.        case DOTTED: 
  468.      LS_LINETO_difficult (xnew, ynew, plotdot); break;
  469.        case DOT_DASHED:
  470.      LS_LINETO_difficult (xnew, ynew, plotdotdash); break;
  471.       }
  472.    }
  473.    xpresent = xnew;
  474.    ypresent = ynew;
  475. }
  476.  
  477. #endif
  478.  
  479. void
  480. SRGP_lineCoord (int x1, int y1, int x2, int y2)
  481. {
  482.    DEBUG_AIDS{
  483.       SRGP_trace (SRGP_logStream, "SRGP_lineCoord: %d,%d --> %d,%d\n", x1,y1,x2,y2);
  484.       srgp_check_system_state();
  485.       LeaveIfNonFatalErr();
  486.    }
  487.  
  488.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  489. #ifdef X11
  490.    XDrawLine
  491.       (srgpx__display,
  492.        srgp__curActiveCanvasSpec.drawable.xid,
  493.        srgp__curActiveCanvasSpec.gc_frame,
  494.        x1, FIXED(y1), x2, FIXED(y2));
  495. #endif
  496. #ifdef THINK_C
  497.    SET_PORT_FOR_FRAME_GENRE();
  498.    LS_MOVETO (x1,FIXED(y1));
  499.    LS_LINETO (x2,FIXED(y2));
  500. #endif
  501.    TURN_ON_RUBBER_ECHO_IF_ANY;
  502. }
  503.  
  504. void
  505. SRGP_line (point pt1, point pt2)
  506. {
  507.    DEBUG_AIDS{
  508.       SRGP_trace (SRGP_logStream, "SRGP_line: %d,%d --> %d,%d\n", ExplodePt(pt1), ExplodePt(pt2));
  509.    }
  510.  
  511.    PUSH_TRACE;
  512.    SRGP_lineCoord (pt1.x, pt1.y,  pt2.x, pt2.y);
  513.    POP_TRACE;
  514. }
  515.  
  516.  
  517.  
  518. /** RECTANGLES
  519. **/
  520.  
  521. void
  522. SRGP_rectangleCoord (int left_x, int bottom_y, int right_x, int top_y)
  523. {
  524.    DEBUG_AIDS{
  525.       SRGP_trace (SRGP_logStream, "SRGP_rectangleCoord: (%d,%d)->(%d,%d)\n",
  526.           left_x, bottom_y, right_x, top_y);
  527.       srgp_check_system_state();
  528.       srgp_check_rectangle (left_x, bottom_y, right_x, top_y);
  529.       LeaveIfNonFatalErr();
  530.    }
  531.  
  532.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  533. #ifdef X11
  534.    XDrawRectangle
  535.       (srgpx__display,
  536.        srgp__curActiveCanvasSpec.drawable.xid,
  537.        srgp__curActiveCanvasSpec.gc_frame,
  538.        left_x, FIXED(top_y),
  539.        (right_x-left_x),
  540.        (top_y-bottom_y));
  541. #endif
  542. #ifdef THINK_C
  543.    SET_PORT_FOR_FRAME_GENRE();
  544.    r = FIXED_RECT(left_x, bottom_y, right_x, top_y);
  545.    if (srgp__curActiveCanvasSpec.attributes.line_style == CONTINUOUS)
  546.       FrameRect (&r);
  547.    else {
  548.       r.bottom -= srgp__curActiveCanvasSpec.attributes.line_width;
  549.       r.right -= srgp__curActiveCanvasSpec.attributes.line_width;
  550.       LS_MOVETO (r.left, r.bottom);
  551.       LS_LINETO (r.right, r.bottom);
  552.       LS_LINETO (r.right, r.top);
  553.       LS_LINETO (r.left, r.top);
  554.       LS_LINETO (r.left, r.bottom);
  555.    }
  556. #endif
  557.    TURN_ON_RUBBER_ECHO_IF_ANY;
  558. }
  559.  
  560. void
  561. SRGP_rectangle (rectangle rect)
  562. {
  563.    DEBUG_AIDS{
  564.       SRGP_trace (SRGP_logStream, "SRGP_rectangle: (%d,%d)->(%d,%d)\n", ExplodeRect(rect));
  565.    }
  566.  
  567.    PUSH_TRACE;
  568.    SRGP_rectangleCoord
  569.       (rect.bottom_left.x, rect.bottom_left.y,
  570.        rect.top_right.x, rect.top_right.y);
  571.    POP_TRACE;
  572. }
  573.  
  574. void
  575. SRGP_rectanglePt (point bottom_left, point top_right)
  576. {
  577.    DEBUG_AIDS{
  578.       SRGP_trace (SRGP_logStream, "SRGP_rectanglePt: (%d,%d)->(%d,%d)\n",
  579.           ExplodePt(bottom_left), ExplodePt(top_right));
  580.    }
  581.  
  582.    PUSH_TRACE;
  583.    SRGP_rectangleCoord
  584.       (bottom_left.x, bottom_left.y,
  585.        top_right.x, top_right.y);
  586.    POP_TRACE;
  587. }
  588.    
  589.  
  590.  
  591.  
  592.  
  593.  
  594.  
  595. /** FRAMED POLYGONS
  596. **/
  597.  
  598. void
  599. SRGP_polyLine (int vertex_count, point *vertices)
  600. {
  601.    register int i;
  602.  
  603.    DEBUG_AIDS{
  604.       SRGP_trace (SRGP_logStream, "SRGP_polyLine  %d 0x%x\n", vertex_count, vertices);
  605.       srgp_check_system_state();
  606.       srgp_check_polyline_list_size(vertex_count);
  607.       LeaveIfNonFatalErr();
  608.    }
  609.  
  610.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  611. #ifdef X11
  612.    for (i=0; i < vertex_count; i++) {
  613.       Xformat_vertices[i].x = vertices[i].x;
  614.       Xformat_vertices[i].y = FIXED(vertices[i].y);
  615.    } 
  616.    XDrawLines
  617.       (srgpx__display,
  618.        srgp__curActiveCanvasSpec.drawable.xid,
  619.        srgp__curActiveCanvasSpec.gc_frame,
  620.        Xformat_vertices, vertex_count, CoordModeOrigin);
  621. #endif
  622. #ifdef THINK_C
  623.    SET_PORT_FOR_FRAME_GENRE();
  624.    LS_MOVETO (vertices[0].x, FIXED(vertices[0].y));
  625.    for (i=1; i < vertex_count; i++)
  626.       LS_LINETO (vertices[i].x, FIXED(vertices[i].y));
  627. #endif
  628.    TURN_ON_RUBBER_ECHO_IF_ANY;
  629. }
  630.  
  631.  
  632. void
  633. SRGP_polyLineCoord (int vertex_count, int *x_coords, int *y_coords)
  634. {
  635.    register int i;
  636.  
  637.    DEBUG_AIDS{
  638.       SRGP_trace (SRGP_logStream, "SRGP_polyLineCoord  %d 0x%x,0x%x\n",
  639.           vertex_count, x_coords, y_coords);
  640.       srgp_check_system_state();
  641.       srgp_check_polyline_list_size(vertex_count);
  642.       LeaveIfNonFatalErr();
  643.    }
  644.  
  645.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  646. #ifdef X11
  647.    for (i=0; i < vertex_count; i++) {
  648.       Xformat_vertices[i].x = x_coords[i];
  649.       Xformat_vertices[i].y = FIXED(y_coords[i]);
  650.    } 
  651.    XDrawLines
  652.       (srgpx__display,
  653.        srgp__curActiveCanvasSpec.drawable.xid,
  654.        srgp__curActiveCanvasSpec.gc_frame,
  655.        Xformat_vertices, vertex_count, CoordModeOrigin);
  656. #endif
  657. #ifdef THINK_C
  658.    SET_PORT_FOR_FRAME_GENRE();
  659.    LS_MOVETO (x_coords[0], FIXED(y_coords[0]));
  660.    for (i=1; i < vertex_count; i++)
  661.       LS_LINETO (x_coords[i], FIXED(y_coords[i]));
  662. #endif
  663.    TURN_ON_RUBBER_ECHO_IF_ANY;
  664. }
  665.  
  666.  
  667. void
  668. SRGP_polygon (int vertex_count, point *vertices)
  669. {
  670.    DEBUG_AIDS{
  671.       SRGP_trace (SRGP_logStream, "SRGP_polygon  %d 0x%x\n", 
  672.           vertex_count, vertices);
  673.       srgp_check_system_state();
  674.       srgp_check_polygon_list_size(vertex_count);
  675.       LeaveIfNonFatalErr();
  676.    }
  677.  
  678.    PUSH_TRACE;
  679.    SRGP_polyLine (vertex_count, vertices);
  680.    /* draw the line between the first vertex and the last vertex */
  681.    SRGP_line (vertices[0], vertices[vertex_count-1]);
  682.    POP_TRACE;
  683. }
  684.  
  685.  
  686. void
  687. SRGP_polygonCoord (int vertex_count, int *x_coords, int *y_coords)
  688. {
  689.    DEBUG_AIDS{
  690.       SRGP_trace (SRGP_logStream, "SRGP_polygonCoord  %d 0x%x,0x%x\n",
  691.           vertex_count, x_coords, y_coords);
  692.       srgp_check_system_state();
  693.       srgp_check_polygon_list_size(vertex_count);
  694.       LeaveIfNonFatalErr();
  695.    }
  696.  
  697.    PUSH_TRACE;
  698.    SRGP_polyLineCoord (vertex_count, x_coords, y_coords);
  699.    /* draw the line between the first vertex and the last vertex */
  700.    SRGP_lineCoord
  701.       (x_coords[0], y_coords[0],
  702.        x_coords[vertex_count-1], y_coords[vertex_count-1]);
  703.    POP_TRACE;
  704. }
  705.  
  706.  
  707.  
  708. /** FILLED RECTANGLES AND POLYGONS
  709. **/
  710.  
  711. void
  712. SRGP_fillRectangleCoord (int left_x, int bottom_y, int right_x, int top_y)
  713. {
  714.    DEBUG_AIDS{
  715.       SRGP_trace (SRGP_logStream, "SRGP_fillRectangleCoord (%d,%d)->(%d,%d)\n",
  716.           left_x, bottom_y, right_x, top_y);
  717.       srgp_check_system_state();
  718.       srgp_check_rectangle(left_x, bottom_y, right_x, top_y);
  719.       LeaveIfNonFatalErr();
  720.    }
  721.  
  722.    
  723.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  724. #ifdef X11
  725.    XFillRectangle
  726.       (srgpx__display,
  727.        srgp__curActiveCanvasSpec.drawable.xid,
  728.        srgp__curActiveCanvasSpec.gc_fill,
  729.        left_x, FIXED(top_y),
  730.        (right_x-left_x+1), (top_y-bottom_y+1));
  731. #endif
  732. #ifdef THINK_C
  733.    SET_PORT_FOR_FILL_GENRE();
  734.    r = FIXED_RECT(left_x, bottom_y, right_x, top_y);
  735.    if (srgp__curActiveCanvasSpec.attributes.fill_style == PIXMAP_PATTERN)
  736.       FillCRect
  737.          (&r,
  738.           srgp__pixmapPatternTable
  739.              [srgp__curActiveCanvasSpec.attributes.fill_pixmap_pattern_id]);
  740.    else
  741.    PaintRect (&r);
  742. #endif
  743.    TURN_ON_RUBBER_ECHO_IF_ANY;  
  744. }
  745.  
  746. void
  747. SRGP_fillRectangle (rectangle rect)
  748. {
  749.    DEBUG_AIDS{
  750.       SRGP_trace (SRGP_logStream, "SRGP_fillRectangle (%d,%d)->(%d,%d)\n", 
  751.           ExplodeRect(rect));
  752.    }
  753.  
  754.    PUSH_TRACE;
  755.    SRGP_fillRectangleCoord
  756.       (rect.bottom_left.x, rect.bottom_left.y,
  757.        rect.top_right.x, rect.top_right.y);
  758.    POP_TRACE;
  759. }
  760.  
  761. void
  762. SRGP_fillRectanglePt (point bottom_left, point top_right)
  763. {
  764.    DEBUG_AIDS{
  765.       SRGP_trace (SRGP_logStream, "SRGP_fillRectanglePt (%d,%d)->(%d,%d)\n",
  766.           ExplodePt(bottom_left), ExplodePt(top_right));
  767.    }
  768.  
  769.    PUSH_TRACE;
  770.    SRGP_fillRectangleCoord
  771.       (bottom_left.x, bottom_left.y,
  772.        top_right.x, top_right.y);
  773.    POP_TRACE;
  774. }
  775.   
  776.  
  777. void
  778. SRGP_fillPolygon (int vertex_count, point *vertices)
  779. {
  780.    register int i;
  781. #ifdef THINK_C
  782.    PolyHandle p;
  783. #endif
  784.  
  785.    DEBUG_AIDS{
  786.       SRGP_trace (SRGP_logStream, "SRGP_fillPolygon:  %d  0x%x\n", 
  787.           vertex_count, vertices);
  788.       srgp_check_system_state();
  789.       srgp_check_polygon_list_size(vertex_count);
  790.       LeaveIfNonFatalErr();
  791.    }
  792.  
  793.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  794.  
  795. #ifdef X11
  796.    for (i=0; i < vertex_count; i++) {
  797.       Xformat_vertices[i].x = vertices[i].x;
  798.       Xformat_vertices[i].y = FIXED(vertices[i].y);
  799.    }
  800.    XFillPolygon
  801.       (srgpx__display,
  802.        srgp__curActiveCanvasSpec.drawable.xid,
  803.        srgp__curActiveCanvasSpec.gc_fill,
  804.        Xformat_vertices, vertex_count, Complex, CoordModeOrigin);
  805. #endif
  806.  
  807. #ifdef THINK_C
  808.    p = OpenPoly();
  809.    MoveTo (vertices[0].x, FIXED(vertices[0].y));
  810.    for (i=1; i < vertex_count; i++)
  811.       LineTo (vertices[i].x, FIXED(vertices[i].y));
  812.    ClosePoly ();
  813.    if (srgp__curActiveCanvasSpec.attributes.fill_style == PIXMAP_PATTERN)
  814.       FillCPoly 
  815.          (p,
  816.           srgp__pixmapPatternTable
  817.              [srgp__curActiveCanvasSpec.attributes.fill_pixmap_pattern_id]);
  818.    else {
  819.       SET_PORT_FOR_FILL_GENRE();
  820.       PaintPoly (p);
  821.    }
  822.    KillPoly (p);
  823. #endif
  824.  
  825.    TURN_ON_RUBBER_ECHO_IF_ANY;
  826. }
  827.  
  828.  
  829. void
  830. SRGP_fillPolygonCoord (int vertex_count, int *x_coords, int *y_coords)
  831. {
  832.    register int i;
  833. #ifdef THINK_C
  834.    PolyHandle p;
  835. #endif
  836.  
  837.    DEBUG_AIDS{
  838.       SRGP_trace (SRGP_logStream, "SRGP_fillPolygonCoord:  %d  0x%x,0x%x\n",
  839.           vertex_count, x_coords, y_coords);
  840.       srgp_check_system_state();
  841.       srgp_check_polygon_list_size(vertex_count);
  842.       LeaveIfNonFatalErr();
  843.    }
  844.  
  845.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  846.    
  847. #ifdef X11
  848.    for (i=0; i < vertex_count; i++) {
  849.       Xformat_vertices[i].x = x_coords[i];
  850.       Xformat_vertices[i].y = FIXED(y_coords[i]);
  851.    }
  852.    XFillPolygon
  853.       (srgpx__display,
  854.        srgp__curActiveCanvasSpec.drawable.xid,
  855.        srgp__curActiveCanvasSpec.gc_fill,
  856.        Xformat_vertices, vertex_count, Complex, CoordModeOrigin);
  857. #endif
  858.  
  859. #ifdef THINK_C
  860.    p = OpenPoly();
  861.    MoveTo (x_coords[0], FIXED(y_coords[0]));
  862.    for (i=1; i < vertex_count; i++)
  863.       LineTo (x_coords[i], FIXED(y_coords[i]));
  864.    ClosePoly ();
  865.    if (srgp__curActiveCanvasSpec.attributes.fill_style == PIXMAP_PATTERN)
  866.       FillCPoly 
  867.          (p,
  868.           srgp__pixmapPatternTable
  869.              [srgp__curActiveCanvasSpec.attributes.fill_pixmap_pattern_id]);
  870.    else {
  871.       SET_PORT_FOR_FILL_GENRE();
  872.       PaintPoly (p);
  873.    }
  874.    KillPoly (p);
  875. #endif
  876.    TURN_ON_RUBBER_ECHO_IF_ANY;
  877. }
  878.  
  879.  
  880.  
  881. /** ELLIPSES
  882. **/
  883.  
  884. #ifdef X11
  885. static int xangle1, xangle2;
  886.  
  887. ComputeXangles (double start, double end)
  888. {
  889.    if (start <= end) {
  890.       xangle1 = (int)(start*64);
  891.       xangle2 = (int)((end-start)*64);
  892.    }
  893.    else {
  894.       xangle1 = (int) (end*64);
  895.       xangle2 = (int) ((start-360.0-end)*64);
  896.    }
  897. }
  898. #endif
  899.    
  900. void
  901. SRGP_ellipseArc (rectangle bounding_rect, double start, double end)
  902. {
  903.  
  904.  
  905.    DEBUG_AIDS{
  906.       SRGP_trace (SRGP_logStream, "SRGP_ellipse:  (%d,%d)->(%d,%d)\n",
  907.           ExplodeRect(bounding_rect));
  908.       srgp_check_system_state();
  909.       srgp_check_rectangle
  910.      (bounding_rect.bottom_left.x, bounding_rect.bottom_left.y,
  911.       bounding_rect.top_right.x, bounding_rect.top_right.y);
  912.       LeaveIfNonFatalErr();
  913.    }
  914.  
  915.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  916. #ifdef X11
  917.    ComputeXangles (start, end);
  918.    XDrawArc
  919.       (srgpx__display,
  920.        srgp__curActiveCanvasSpec.drawable.xid,
  921.        srgp__curActiveCanvasSpec.gc_frame,
  922.        bounding_rect.bottom_left.x, FIXED(bounding_rect.top_right.y),
  923.        (bounding_rect.top_right.x - bounding_rect.bottom_left.x),
  924.        (bounding_rect.top_right.y - bounding_rect.bottom_left.y),
  925.        xangle1, xangle2);
  926. #endif
  927. #ifdef THINK_C
  928.    SetRect (&r, bounding_rect.bottom_left.x, FIXED(bounding_rect.top_right.y),
  929.            bounding_rect.top_right.x, FIXED(bounding_rect.bottom_left.y));
  930.    SET_PORT_FOR_FRAME_GENRE();
  931.    FrameArc (&r, (int)(90 - start), (int)(-(end+((start>end)?360:0) - start)));
  932. #endif
  933.    TURN_ON_RUBBER_ECHO_IF_ANY;
  934. }
  935.  
  936.  
  937. void
  938. SRGP_ellipse (rectangle bounding_rect)
  939. {
  940.    DEBUG_AIDS{
  941.       SRGP_trace (SRGP_logStream, "SRGP_ellipse:  (%d,%d)->(%d,%d)\n",
  942.           ExplodeRect(bounding_rect));
  943.       srgp_check_system_state();
  944.       srgp_check_rectangle
  945.      (bounding_rect.bottom_left.x, bounding_rect.bottom_left.y,
  946.       bounding_rect.top_right.x, bounding_rect.top_right.y);
  947.       LeaveIfNonFatalErr();
  948.    }
  949.  
  950.    PUSH_TRACE;
  951.    SRGP_ellipseArc (bounding_rect, 0.0, 360.0);
  952.    POP_TRACE;
  953. }
  954.  
  955.  
  956.  
  957.  
  958. void
  959. SRGP_fillEllipseArc (rectangle bounding_rect, double start, double end)
  960. {
  961.    DEBUG_AIDS{
  962.       SRGP_trace (SRGP_logStream, "SRGP_fillEllipseArc:  (%d,%d)->(%d,%d)\n",
  963.           ExplodeRect(bounding_rect));
  964.       srgp_check_system_state();
  965.       srgp_check_rectangle
  966.      (bounding_rect.bottom_left.x, bounding_rect.bottom_left.y,
  967.       bounding_rect.top_right.x, bounding_rect.top_right.y);
  968.       LeaveIfNonFatalErr();
  969.    }
  970.  
  971.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  972. #ifdef X11
  973.    ComputeXangles (start, end);
  974.    XFillArc
  975.       (srgpx__display,
  976.        srgp__curActiveCanvasSpec.drawable.xid,
  977.        srgp__curActiveCanvasSpec.gc_fill,
  978.        bounding_rect.bottom_left.x, FIXED(bounding_rect.top_right.y),
  979.        (bounding_rect.top_right.x - bounding_rect.bottom_left.x),
  980.        (bounding_rect.top_right.y - bounding_rect.bottom_left.y),
  981.        xangle1, xangle2);
  982. #endif
  983.  
  984. #ifdef THINK_C
  985.    SetRect (&r, bounding_rect.bottom_left.x, FIXED(bounding_rect.top_right.y),
  986.            bounding_rect.top_right.x, FIXED(bounding_rect.bottom_left.y));
  987.    if (srgp__curActiveCanvasSpec.attributes.fill_style == PIXMAP_PATTERN)
  988.       FillCArc (&r, (int)(90 - start), (int)(-(end+((start>end)?360:0) - start)),
  989.                 srgp__pixmapPatternTable
  990.                    [srgp__curActiveCanvasSpec.attributes.fill_pixmap_pattern_id]);
  991.    else {
  992.       SET_PORT_FOR_FILL_GENRE();
  993.       PaintArc (&r, (int)(90 - start), (int)(-(end+((start>end)?360:0) - start)));
  994.    }
  995. #endif
  996.    TURN_ON_RUBBER_ECHO_IF_ANY;
  997. }
  998.  
  999.  
  1000.  
  1001. void
  1002. SRGP_fillEllipse (rectangle bounding_rect)
  1003. {
  1004.    DEBUG_AIDS{
  1005.       SRGP_trace (SRGP_logStream, "SRGP_fillEllipse:  (%d,%d)->(%d,%d)\n",
  1006.           ExplodeRect(bounding_rect));
  1007.       srgp_check_system_state();
  1008.       srgp_check_rectangle
  1009.      (bounding_rect.bottom_left.x, bounding_rect.bottom_left.y,
  1010.       bounding_rect.top_right.x, bounding_rect.top_right.y);
  1011.       LeaveIfNonFatalErr();
  1012.    }
  1013.  
  1014.    PUSH_TRACE;
  1015.    SRGP_fillEllipseArc (bounding_rect, 0.0, 360.0);
  1016.    POP_TRACE;
  1017. }
  1018.  
  1019.  
  1020.  
  1021. /** TEXT
  1022. X11 implementation notes:
  1023.    Unfortunately, we don't keep a GC around just for text.
  1024.    Neither the frame nor the fill GC are necessarily correct for text;
  1025.    text is always drawn in SOLID style.
  1026.  
  1027.    Basically, if we find that the frame GC currently has a non-solid X-fill-style,
  1028.    we temporarily change the frame GC's X-fill-style to SOLID and then restore.
  1029.  
  1030.    This could be woefully inefficient if the application is indeed using
  1031.    a non-solid pen-style!
  1032. **/
  1033.  
  1034. void
  1035. SRGP_text (point origin, char *str)
  1036. {
  1037. #ifdef X11
  1038.    boolean restoration_needed = FALSE;
  1039. #endif
  1040.  
  1041.    DEBUG_AIDS{
  1042.       SRGP_trace (SRGP_logStream, "SRGP_text:  %d,%d  %s\n", 
  1043.           origin.x, origin.y, str);
  1044.       srgp_check_system_state();
  1045.       LeaveIfNonFatalErr();
  1046.    }
  1047.  
  1048.    TURN_OFF_RUBBER_ECHO_IF_ANY;
  1049.  
  1050. #ifdef X11
  1051.    if (srgp__curActiveCanvasSpec.attributes.pen_style != SOLID) {
  1052.       restoration_needed = TRUE;
  1053.       XSetFillStyle (srgpx__display,
  1054.              srgp__curActiveCanvasSpec.gc_frame, SOLID);
  1055.    }
  1056.  
  1057.    XDrawString
  1058.       (srgpx__display,
  1059.        srgp__curActiveCanvasSpec.drawable.xid,
  1060.        srgp__curActiveCanvasSpec.gc_frame,
  1061.        origin.x, FIXED(origin.y), str, strlen(str));
  1062.  
  1063.    if (restoration_needed)
  1064.       XSetFillStyle (srgpx__display,
  1065.              srgp__curActiveCanvasSpec.gc_frame,
  1066.              srgp__curActiveCanvasSpec.attributes.pen_style);
  1067. #endif
  1068.  
  1069. #ifdef THINK_C
  1070.    PenPat(black);
  1071.    CtoPstr(str);
  1072.    MoveTo (origin.x, FIXED(origin.y));
  1073.    DrawString (str);
  1074.    PtoCstr(str);
  1075. #endif
  1076.  
  1077.    TURN_ON_RUBBER_ECHO_IF_ANY;
  1078. }
  1079.